home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / Telnet 2.6.1d1 4⁄26⁄94 Folder / Krb / KrbDriver.h < prev    next >
Text File  |  1993-10-13  |  10KB  |  271 lines
  1. /*
  2.     KrbDriver.h -- Application interface for Kerberos Client (mac system extension)
  3.     This interface can be used as is or it can be accessed at a higher level using
  4.     the c++ interface (Kerberos.h).
  5.     
  6.     Set the compiler def KRB_DRIVER only if you are including krb.h in your code
  7.     (this is only necessary for the driver itself)
  8.     
  9.     
  10.     © Copyright 1992 by Cornell University
  11.     
  12.     Initial coding 1/92 by Peter Bosanko.
  13. */
  14.  
  15. #ifndef _KrbDriver_    
  16. #define    _KrbDriver_
  17.  
  18. /* csCodes for Control Calls */
  19. enum {
  20.     cKrbKillIO = 1,
  21.  
  22.     /* Low level routines, here for compatability with Brown Driver */
  23.     cKrbGetLocalRealm,
  24.     cKrbSetLocalRealm,
  25.     cKrbGetRealm,
  26.     cKrbAddRealmMap,
  27.     cKrbDeleteRealmMap,
  28.     cKrbGetNthRealmMap,
  29.     cKrbGetNthServer,
  30.     cKrbAddServerMap,
  31.     cKrbDeleteServerMap,
  32.     cKrbGetNthServerMap,
  33.     cKrbGetNumSessions,
  34.     cKrbGetNthSession,
  35.     cKrbDeleteSession,
  36.     cKrbGetCredentials,
  37.     cKrbAddCredentials,
  38.     cKrbDeleteCredentials,
  39.     cKrbGetNumCredentials,
  40.     cKrbGetNthCredentials,
  41.             
  42.     /* High Level routines */
  43.     cKrbDeleteAllSessions,
  44.     /* Removes all credentials from storage.                   
  45.        The user will be asked to enter user name and password the next time a ticket is requested */ 
  46.  
  47.     cKrbGetTicketForService,
  48.     /* Gets a ticket and returns it to application in buf
  49.           -> service                Formal Kerberos name of service
  50.           -> buf                    Buffer to receive ticket
  51.           -> checksum                checksum for this service
  52.          <-> buflen                    length of ticket buffer (must be at least 1258 bytes)
  53.          <-  sessionKey                for internal use
  54.          <-  schedule                for internal use                                */
  55.  
  56.     cKrbGetAuthForService,
  57.     /* Similiar to cKrbGetTicketForService except it builds a kerberos "SendAuth" style
  58.        request (with SendAuth and application version numbers preceeding the actual ticket)
  59.           -> service                Formal Kerberos name of service
  60.           -> buf                    Buffer to receive ticket
  61.           -> checksum                checksum for this service
  62.           -> applicationVersion        version number of the application (8 byte string)
  63.           <-> buflen                    length of ticket buffer (must be at least 1258 bytes)
  64.          <-  sessionKey                for internal use
  65.          <-  schedule                for internal use                                */
  66.  
  67.     // Use the same krbHiParmBlock for the routines below that you used to get the ticket for the service.
  68.     // That way the session key and schedule will get passed back to the driver.
  69.     
  70.     cKrbCheckServiceResponse,
  71.     /* Use the return code from this call to determine if the client is properly authenticated
  72.           -> buf                    points to the begining of the server response
  73.           -> buflen                length of the server response
  74.           -> sessionKey            this was returned from cKrbGetTicketForService call    
  75.           -> schedule                "    
  76.           -> checksum                left over from cKrbGetTicketForService call
  77.           -> lAddr                addresses used for service validation...
  78.           -> lPort                "
  79.           -> fAddr                "
  80.           -> fPort                "                                             */
  81.  
  82.     cKrbEncrypt,
  83.     /* Encrypt stream, High level version of cKrbMakePrivate
  84.           -> buf                    points to the begining of stream buffer
  85.           -> buflen                length of the stream buffer
  86.           -> sessionKey            this was returned from cKrbGetTicketForService call    
  87.           -> schedule                "    
  88.           -> lAddr                server uses addresses to confirm who we are...
  89.           -> lPort                "
  90.           -> fAddr                "
  91.           -> fPort                "
  92.           -> encryptBuf            output buffer, allow 26 more bytes than input data            
  93.           <- encryptLength        actual length of output data                            */                
  94.  
  95.     cKrbDecrypt,
  96.     /* Decrypt stream, High level version of cKrbReadPrivate
  97.           -> buf                    points to the begining of stream buffer
  98.           -> buflen                length of the stream buffer
  99.           -> sessionKey            this was returned from cKrbGetTicketForService call    
  100.           -> schedule                "    
  101.           -> lAddr                addresses used to confirm source of message...
  102.           -> lPort                "
  103.           -> fAddr                "
  104.           -> fPort                "
  105.           <- decryptOffset        offset in buf to beginning of application data            
  106.           <- decryptLength        actual length of decrypted data                           */
  107.           
  108.     cKrbCacheInitialTicket,
  109.     /* Gets a ticket for the ticket granting service and optionally another service that you specify.
  110.        This call always prompts the user for a password.  The ticket(s) are placed in the ticket cache
  111.        but are not returned.  Use cKrbGetTicketForService to receive the ticket.
  112.        NOTE: This call is useful for getting a ticket for the password changing service or any other
  113.        service that requires that the user be reauthenticated ( that needs an initial ticket ).
  114.        
  115.           -> service            Formal Kerberos name of service
  116.                                   ( NULL service is OK if you just want a ticket granting ticket ) */
  117.                                 
  118.     cKrbGetUserName,
  119.     /* Get the kerberos name of the user.  If the user is not logged in, returns error cKrbNotLoggedIn.
  120.        
  121.           <- user                Name that user typed in loggin dialog             */
  122.  
  123.     cKrbSetUserName,
  124.     /* Set the kerberos name of the user.  If the user is logged in, cKrbSetUserName logged the user out.
  125.        
  126.           -> user                Name that will be used as default in loggin dialog */
  127.  
  128.     cKrbSetPassword,
  129.     /* Sets the password which will be used the next time a password is needed
  130.         This can be used to bypass the loggin dialog.
  131.         NOTE: Password is cleared from memory after it is used once or
  132.         whenever a cKrbSetUserName or cKrbDeleteAllSessions call is made.
  133.           -> user                    contains password (of current user)            */
  134.  
  135.     cKrbGetDesPointers
  136.     /* Returns a block of pointers to DES routines so the routines can be
  137.         called directly. */
  138.     };
  139.  
  140. /* Password changing service */
  141.  
  142. #define KRB_PASSWORD_SERVICE  "changepw.kerberos"
  143.  
  144. // Error codes
  145. enum {
  146.     cKrbCorruptedFile = -1024,    /* couldn't find a needed resource */
  147.     cKrbNoKillIO,                /* can't killIO because all calls sync */
  148.     cKrbBadSelector,            /* csCode passed doesn't select a recognized function */
  149.     cKrbCantClose,                /* we must always remain open */
  150.     cKrbMapDoesntExist,            /* tried to access a map that doesn't exist (index too large,
  151.                                     or criteria doesn't match anything) */
  152.     cKrbSessDoesntExist,        /* tried to access a session that doesn't exist */
  153.     cKrbCredsDontExist,            /* tried to access credentials that don't exist */
  154.     cKrbTCPunavailable,            /* couldn't open MacTCP driver */
  155.     cKrbUserCancelled,            /* user cancelled a log in operation */
  156.     cKrbConfigurationErr,        /* Kerberos Preference file is not configured properly */
  157.     cKrbServerRejected,            /* A server rejected our ticket */
  158.     cKrbServerImposter,            /* Server appears to be a phoney */
  159.     cKrbServerRespIncomplete,    /* Server response is not complete */
  160.     cKrbNotLoggedIn,            /* Returned by cKrbGetUserName if user is not logged in */
  161.     cKrbOldDriver,                /* old version of the driver */
  162.     
  163.     cKrbKerberosErrBlock = -20000    /* start of block of 256 kerberos errors */
  164.     };
  165.     
  166. // Parameter block for high level calls
  167. struct krbHiParmBlock    {
  168.             char             *service;        /* full name -- combined service, instance, realm */
  169.             char              *buf;
  170.             unsigned long      buflen;
  171.             long             checksum;
  172.             unsigned long    lAddr;
  173.             unsigned short    lPort;
  174.             unsigned long    fAddr;
  175.             unsigned short    fPort;
  176.             unsigned long    decryptOffset;
  177.             unsigned long    decryptLength;
  178.             char             *encryptBuf;
  179.             unsigned long    encryptLength;
  180.             char             *applicationVersion;    /* Version string must be 8 bytes long!     */
  181.             char             sessionKey[8];            /* for internal use                      */
  182.             char            schedule[128];            /* for internal use                      */
  183.             char             *user;
  184. };
  185. typedef struct krbHiParmBlock krbHiParmBlock;
  186. typedef krbHiParmBlock *KrbParmPtr;
  187. typedef KrbParmPtr *KrbParmHandle;
  188.  
  189. /* ********************************************************* */
  190. /* The rest of these defs are for low level calls
  191. /* ********************************************************* */
  192. #ifndef KRB_DRIVER
  193. /* First some kerberos defs */
  194.  
  195. typedef unsigned char des_cblock[8];    /* crypto-block size */
  196.  
  197. /* Key schedule */
  198. typedef struct des_ks_struct { des_cblock _; } des_key_schedule[16];
  199.  
  200. #define C_Block des_cblock
  201. #define Key_schedule des_key_schedule
  202.  
  203. /* The maximum sizes for aname, realm, sname, and instance +1 */
  204. #define     ANAME_SZ    40
  205. #define        REALM_SZ    40
  206. #define        SNAME_SZ    40
  207. #define        INST_SZ        40
  208.  
  209. /* Definition of text structure used to pass text around */
  210. #define        MAX_KTXT_LEN    1250
  211.  
  212. struct ktext {
  213.     long     length;        /* Length of the text */
  214.     unsigned char dat[MAX_KTXT_LEN];    /* The data itself */
  215.     unsigned long mbz;        /* zero to catch runaway strings */
  216. };
  217.  
  218. typedef struct ktext *KTEXT;
  219. typedef struct ktext KTEXT_ST;
  220.  
  221. struct credentials {
  222.     char    service[ANAME_SZ];    /* Service name */
  223.     char    instance[INST_SZ];    /* Instance */
  224.     char    realm[REALM_SZ];    /* Auth domain */
  225.     C_Block session;        /* Session key */
  226.     long     lifetime;        /* Lifetime */
  227.     long     kvno;        /* Key version number */
  228.     KTEXT_ST ticket_st;        /* The ticket itself */
  229.     long    issue_date;        /* The issue time */
  230.     char    pname[ANAME_SZ];    /* Principal's name */
  231.     char    pinst[INST_SZ];    /* Principal's instance */
  232. };
  233.  
  234. typedef struct credentials CREDENTIALS;
  235.  
  236. /* Structure definition for rd_private_msg and rd_safe_msg */
  237.  
  238. struct msg_dat {
  239.     unsigned char *app_data;    /* pointer to appl data */
  240.     unsigned long app_length;    /* length of appl data */
  241.     unsigned long hash;        /* hash to lookup replay */
  242.     long     swap;        /* swap bytes? */
  243.     long    time_sec;        /* msg timestamp seconds */
  244.     unsigned char time_5ms;    /* msg timestamp 5ms units */
  245. };
  246.  
  247. typedef struct msg_dat MSG_DAT;
  248.  
  249. typedef unsigned long u_long;
  250. typedef unsigned short u_short;
  251.  
  252. #endif
  253.  
  254.  
  255. /* Parameter block for low level calls */        
  256. struct krbParmBlock    {
  257.             char    *uName;
  258.             char    *uInstance;
  259.             char    *uRealm;            /* also where local realm or mapping realm passed */
  260.             char    *sName;
  261.             char    *sInstance;
  262.             char    *sRealm;
  263.             char    *host;                /* also netorhost */
  264.             long    admin;                /* isadmin, mustadmin */
  265.             long    *itemNumber;
  266.             long    *adminReturn;        /* when it needs to be passed back */
  267.             CREDENTIALS *cred;
  268. };
  269. typedef struct krbParmBlock krbParmBlock;
  270.  
  271. #endif